home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CUCD / Graphics / STIMP_noise / source / pgmpseudomedian / pgmpseudomedian.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-30  |  5.4 KB  |  253 lines
  1.  
  2. /************************************************************************/
  3. #define OP_NAME      "pgmpseudomedian"
  4. #define VERSION      "1.01"
  5. #define DATE         "30.01.98"
  6. #define AUTHOR       "Stefan Diener"
  7. /************************************************************************/
  8.  
  9. #include <stdio.h>
  10. #include <stdarg.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14.  
  15. #include <STIMP/pgm.c>
  16.  
  17. struct PGM_Info source, desti;
  18. static int m, n;
  19. static int edge=1;
  20. static int form=1;
  21.  
  22. void seqauswertung(unsigned char *feld, unsigned char *maxi, unsigned char *mini)
  23. /* bestimmt MAXIMIN und MINIMAX aller Teilsequenzen */
  24. {
  25.   unsigned char mami=0, mima=255, ma, mi;
  26.   int i, j;
  27.  
  28.   for (i=0; i<=edge; i++)   /* Zahl der Teilsequenzen */
  29.   {
  30.     ma=feld[i];
  31.     mi=feld[i];
  32.  
  33.     for (j=i+1; j<=i+edge; j++)   /* Zahl der Elemente einer Teilsequenz */
  34.     {
  35.       /* MAX und MIN dieser Teilsequenz suchen */
  36.       if (feld[j]>ma) ma=feld[j];
  37.       else
  38.         if (feld[j]<mi) mi=feld[j];
  39.     }
  40.  
  41.     /* vorlaeufiges MAXIMIN und MINIMAX merken */
  42.     if (mami<mi) mami=mi;
  43.     if (mima>ma) mima=ma;
  44.   }
  45.  
  46.   /* Ergebnisse nach aussen uebermitteln */
  47.   *maxi=mami;
  48.   *mini=mima;
  49. }
  50.  
  51. void Do_It_plus(void)
  52. {
  53.   int i, x, y, k, l, index;
  54.   unsigned char array[9], maximinx, maximiny, minimaxx, minimaxy;
  55.   unsigned char *src, *dst;
  56.  
  57.   /* Zeiger auf Bilddaten holen */
  58.   src=source.Data;
  59.   dst=desti.Data;
  60.   desti.maxval=source.maxval;
  61.  
  62.   /* fuer jeden Punkt ausser Rand */
  63.   for (y=edge; y<m-edge; y++)
  64.     for (x=edge; x<n-edge; x++)
  65.     {
  66.       /* Position berechnen */
  67.       index=y*n+x;
  68.  
  69.       /* Feld fuellen in x-Richtung */
  70.       i=0;
  71.       for (k=-edge; k<=edge; k++) array[i++]=src[index+k];
  72.       seqauswertung(array, &maximinx, &minimaxx);
  73.  
  74.       /* Feld fuellen in y-Richtung */
  75.       i=0;
  76.       for (l=-edge; l<=edge; l++) array[i++]=src[index+l*n];
  77.       seqauswertung(array, &maximiny, &minimaxy);
  78.  
  79.       /* Pseudomedian des Feldes bestimmen */
  80.       if (maximiny>maximinx) maximinx=maximiny;
  81.       if (minimaxy<minimaxx) minimaxx=minimaxy;
  82.       dst[(y-edge)*(n-2*edge)+x-edge]=(maximinx+minimaxx)/2;
  83.     }
  84. }
  85.  
  86. void Do_It_waage(void)
  87. {
  88.   int i, x, y, k, index;
  89.   unsigned char array[9], maximin, minimax;
  90.   unsigned char *src, *dst;
  91.  
  92.   /* Zeiger auf Bilddaten holen */
  93.   src=source.Data;
  94.   dst=desti.Data;
  95.   desti.maxval=source.maxval;
  96.  
  97.   /* fuer jeden Punkt ausser Rand */
  98.   for (y=0; y<m; y++)
  99.     for (x=edge; x<n-edge; x++)
  100.     {
  101.       /* Position berechnen */
  102.       index=y*n+x;
  103.       i=0;
  104.  
  105.       /* Feld fuellen in x-Richtung */
  106.       for (k=-edge; k<=edge; k++) array[i++]=src[index+k];
  107.       seqauswertung(array, &maximin, &minimax);
  108.  
  109.       /* Pseudomedian des Feldes bestimmen */
  110.       dst[y*(n-2*edge)+x-edge]=(maximin+minimax)/2;
  111.     }
  112. }
  113.  
  114. void Do_It_senk(void)
  115. {
  116.   int i, x, y, l, index;
  117.   unsigned char array[9], maximin, minimax;
  118.   unsigned char *src, *dst;
  119.  
  120.   /* Zeiger auf Bilddaten holen */
  121.   src=source.Data;
  122.   dst=desti.Data;
  123.   desti.maxval=source.maxval;
  124.  
  125.   /* fuer jeden Punkt ausser Rand */
  126.   for (y=edge; y<m-edge; y++)
  127.     for (x=0; x<n; x++)
  128.     {
  129.       /* Position berechnen */
  130.       index=y*n+x;
  131.       i=0;
  132.  
  133.       /* Feld fuellen in y-Richtung */
  134.       for (l=-edge; l<=edge; l++) array[i++]=src[index+l*n];
  135.       seqauswertung(array, &maximin, &minimax);
  136.  
  137.       /* Pseudomedian des Feldes bestimmen */
  138.       dst[(y-edge)*n+x]=(maximin+minimax)/2;
  139.     }
  140. }
  141.  
  142. int main(int argc,char **argv)
  143. /* main program */
  144. {
  145.   int i, edgex, edgey;
  146.  
  147.   /* say hello */
  148.   PrintOpening(argc,argv);
  149.  
  150.   /* read the parameters */
  151.   for (i=1; i<argc; i++)
  152.   {
  153.     if ((argv[i][0]=='-') && argv[i][1])
  154.     {
  155.       switch (argv[i][1])
  156.       {
  157.         case '3': edge=1;
  158.                       break;
  159.  
  160.         case '5': edge=2;
  161.                       break;
  162.  
  163.         case '7': edge=3;
  164.                       break;
  165.  
  166.         case '9': edge=4;
  167.                       break;
  168.  
  169.         case 'e': form=3;
  170.                       break;
  171.  
  172.         case 'h': form=2;
  173.                       break;
  174.  
  175.         case 'p': form=1;
  176.                       break;
  177.  
  178.         case 'v': beVerbose=FALSE;
  179.                       break;
  180.  
  181.         default: PrintMessage("Unknown parameter: %s", argv[i]);
  182.                      Hilfe();
  183.                      exit(-1);
  184.                      break;
  185.       }
  186.     }
  187.  
  188.     if (argv[i][0]=='+')
  189.     {
  190.       switch (argv[i][1])
  191.       {
  192.         case 'v': beVerbose=TRUE;
  193.                       break;
  194.  
  195.         default: PrintMessage("Unknown parameter: %s", argv[i]);
  196.                      Hilfe();
  197.                      exit(-1);
  198.                      break;
  199.       }
  200.     }
  201.   }
  202.  
  203.   /* check minimal number of arguments */
  204.   if (argc<3)
  205.   {
  206.     PrintMessage("Not enough arguments !");
  207.     Hilfe();
  208.     exit(-1);
  209.   }
  210.  
  211.   /* check number of file names */
  212.   if (FilenameCount(argc, argv)!=2)
  213.   {
  214.     PrintMessage("Wrong number of file names !");
  215.     Hilfe();
  216.     exit(-1);
  217.   }
  218.  
  219.   if (ReadPGMFile(GetFilename(1,argc,argv),&source)==0)
  220.   {
  221.     m=source.height;
  222.     n=source.width;
  223.  
  224.     /* Aussenraender festlegen */
  225.     edgex=(form==3) ? 0 : edge;
  226.     edgey=(form==2) ? 0 : edge;
  227.  
  228.     if (CreatePGMArray(m-2*edgey, n-2*edgex, &desti)==0)
  229.     {
  230.       PrintMessage("Working ...");
  231.  
  232.       /* Pseudomedian-Filterung */
  233.       switch (form)
  234.       {
  235.         case 1: Do_It_plus();  break;
  236.  
  237.         case 2: Do_It_waage();  break;
  238.  
  239.         case 3: Do_It_senk();  break;
  240.       }
  241.  
  242.       WritePGMFile(GetFilename(2,argc,argv),&desti);
  243.       FreePGMArray(&desti);
  244.     }
  245.  
  246.     FreePGMArray(&source);
  247.   }
  248.  
  249.   PrintClosing();
  250.   exit(0);
  251. }
  252.  
  253.